(FILECREATED "21-OCT-73 21:58:49" PUP2)


(DEFINEQ

(AD
  [LAMBDA (L)
    (SETQ PUP2FNS (SORT (APPEND PUP2FNS L)))
    (SETQ PUP2FNS (INTERSECTION PUP2FNS PUP2FNS))
    (MAKEFILE (QUOTE PUP2])

(ASK:FOR:1
  [LAMBDA (CORRECT:CLASS:NAME)
    (SET CORRECT:CLASS:NAME (READ))
    (SETQ CORRECT:CLASS:NAME (EVAL CORRECT:CLASS:NAME))
    (COND
      ([AND (NOT (MEMBER CORRECT:CLASS:NAME 
                         LIST:OF:POSSIBLE:CLASS:NAMES))
            (AND (NOT (EQUAL CORRECT:CLASS:NAME (QUOTE NIL)))
                 (NOT (EQUAL CORRECT:CLASS:NAME (QUOTE NOTHING]
        (INSERT:1:LIST:OF:CLASS:NAMES CORRECT:CLASS:NAME))
      ((MEMBER CORRECT:CLASS:NAME LIST:OF:POSSIBLE:CLASS:NAMES)
        (RECONCILE:1 CORRECT:CLASS:NAME ELEMENT])

(ASK:FOR:2
  [LAMBDA (FILE:NAME)
    (PRINT (QUOTE (WHAT FILE NAME SHOULD I USE
                     IN CASE I DUMP OUT ALL MY KNOWLEDGE?)))
    (SETQ FILE:NAME (READ])

(CF
  [LAMBDA NIL
    (INITIALIZE:1)
    (PARTITION:A:DOMAIN])

(COMPARE:1
  [LAMBDA (POSSIBLE:CLASS:NAME ELEMENT)
    (PROGN (SETQ LIST:OF:OBJECTS:OF:POSSIBLE:CLASS (GETP 
                                                POSSIBLE:CLASS:NAME 
                                                      CLASS:OBJECTS))
           (COMPARE:1:1 LIST:OF:OBJECTS:OF:POSSIBLE:CLASS 
                        LIST:OF:OBJECTS:OF:ELEMENT)
           (COMPARE:1:2 SET:OF:RELATIONS:OF:POSSIBLE:CLASS 
                        POSSIBLE:CLASS:NAME])

(COMPARE:1:1
  [LAMBDA (LIST:OF:OBJECTS:OF:POSSIBLE:CLASS LIST:OF:OBJECTS:OF:ELEMENT)
    T])

(COMPARE:1:2
  [LAMBDA (SET:OF:RELATIONS:OF:POSSIBLE:CLASS SET:OF:RELATIONS 
                                              POSSIBLE:CLASS:NAME)
    (PROGN (SETQ SET:OF:YES:RELATIONS (GETP POSSIBLE:CLASS:NAME 
                                            YES:RELATIONS))
           (SETQ SET:OF:NO:RELATIONS (GETP POSSIBLE:CLASS:NAME 
                                           NO:RELATIONS))
           (SETQ SET:OF:MAYBE:RELATIONS (GETP POSSIBLE:CLASS:NAME 
                                              MAYBE:RELATIONS))
           (COMPARE:1:2:1 SET:OF:YES:RELATIONS SET:OF:RELATIONS)
           (COMPARE:1:2:2 SET:OF:NO:RELATIONS SET:OF:RELATIONS)
           (COMPARE:1:2:3 SET:OF:MAYBE:RELATIONS SET:OF:RELATIONS])

(COMPARE:1:2:1
  [LAMBDA (SET:OF:YES:RELATIONS SET:OF:RELATIONS)
    (FOREACH:1:2:1 (QUOTE YES:RELATION) IN SET:OF:YES:RELATIONS
       DO
       UNTIL (QUOTE (CONTRADICTS:1 YES:RELATION SET:OF:RELATIONS))
             (QUOTE (COMPARE:1:2:1:1 YES:RELATION SET:OF:RELATIONS])

(COMPARE:1:2:1:1
  [LAMBDA (MAYBE:RELATION SET:OF:RELATIONS)
    T])

(COMPARE:1:2:2
  [LAMBDA (SET:OF:NO:RELATIONS SET:OF:RELATIONS)
    (FOREACH:1:2:2 (QUOTE NO:RELATION) IN SET:OF:NO:RELATIONS
       DO
       UNTIL (QUOTE (CONTRADICTS:2 NO:RELATION SET:OF:RELATIONS))
             (QUOTE (COMPARE:1:2:2:1 NO:RELATION SET:OF:RELATIONS])

(COMPARE:1:2:2:1
  [LAMBDA (NO:RELATION SET:OF:RELATIONS)
    T])

(COMPARE:1:2:3
  [LAMBDA (SET:OF:MAYBE:RELATIONS SET:OF:RELATIONS)
    (FOREACH:1:2:3 (QUOTE MAYBE:RELATION) IN SET:OF:MAYBE:RELATIONS
       DO
       UNTIL (QUOTE (CONTRADICTS:3 MAYBE:RELATION SET:OF:RELATIONS))
             (QUOTE (COMPARE:1:2:3:1 MAYBE:RELATION SET:OF:RELATIONS])

(COMPARE:1:2:3:1
  [LAMBDA (MAYBE:RELATION SET:OF:RELATIONS)
    T])

(CONTRADICTS:1
  [LAMBDA (YES:RELATION SET:OF:RELATIONS)
    (NOT (MEMBER YES:RELATION SET:OF:RELATIONS])

(CONTRADICTS:2
  [LAMBDA (NO:RELATION SET:OF:RELATIONS)
    (MEMBER NO:RELATION SET:OF:RELATIONS])

(CONTRADICTS:3
  [LAMBDA (MAYBE:RELATION SET:OF:RELATIONS)
    NIL])

(CORRESPONDING:OBJECTS:PART
  [LAMBDA (ELEMENT)
    (CADR ELEMENT])

(CORRESPONDING:RELATIONS:PART
  [LAMBDA (ELEMENT)
    (CDDR ELEMENT])

(DELETE:1:1
  [LAMBDA (RELATION P:LIST)
    (PROG (TEMPORARY:MAYBE:RELATIONS)
          (SETQ TEMPORARY:MAYBE:RELATIONS (GETP CLASS:NAME 
                                                MAYBE:RELATIONS))
          (SETQ TEMPORARY:MAYBE:RELATIONS (PULLOUT RELATION 
                                          TEMPORARY:MAYBE:RELATIONS))
          (PUT CLASS:NAME MAYBE:RELATIONS TEMPORARY:MAYBE:RELATIONS])

(DETERMINE:1:CLASS:NAME
  [LAMBDA NIL
    (FOREACH:1 (QUOTE POSSIBLE:CLASS:NAME) IN 
                                       LIST:OF:POSSIBLE:CLASS:NAMES
       DO (QUOTE (TEST:1 POSSIBLE:CLASS:NAME)))
    (ASKFOR:1 (QUOTE CORRECT:CLASS:NAME))
    (COND
      ((NOT (EQUAL CLASS:NAME (QUOTE FAILURE)))
        (COND
          ([COND
              ([AND (NOT (EQUAL CLASS:NAME CORRECT:CLASS:NAME))
                    (NOT (NULL (SETDIFFERENCE SET:OF:MAYBE:RELATIONS 
                                              SET:OF:RELATIONS]
                (FORSOME:1 (QUOTE RELATION) IN (SETDIFFERENCE 
                                             SET:OF:MAYBE:RELATIONS 
                                                   SET:OF:RELATIONS)
                   DO (QUOTE (TRANSFER:1 RELATION FROM 
                                             SET:OF:MAYBE:RELATIONS
                                TO SET:OF:YES:RELATIONS]
            T)
          (T (COND
               ([AND (NOT (EQUAL CLASS:NAME CORRECT:CLASS:NAME))
                     (NOT (NULL (SETDIFFERENCE SET:OF:RELATIONS 
                                             SET:OF:MAYBE:RELATIONS]
                 (FORSOME:2 (QUOTE RELATION) IN (SETDIFFERENCE 
                                                   SET:OF:RELATIONS 
                                             SET:OF:MAYBE:RELATIONS)
                    DO (QUOTE (TRANSFER:2 RELATION FROM 
                                                   SET:OF:RELATIONS
                                 TO SET:OF:NO:RELATIONS])

(DISK:DUMP
  [LAMBDA (FILE STUFF)
    (SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
                                   "VARS")))
    (SET FILEVARS (QUOTE STUFF))
    (MAKEFILE FILE])

(FOREACH
  [LAMBDA (X IN SET DO ACTION)
    (PROG (RESULT)
      START:HERE
          (COND
            ((NULL SET)
              (RETURN RESULT)))
          (SET X (CAR SET))
          (SETQ SET (CDR SET))
          (SETQ RESULT (EVAL ACTION))
          (GO START:HERE])

(FOREACH:1
  [LAMBDA (POSSIBLE:CLASS:NAME IN LIST:OF:POSSIBLE:CLASS:NAMES
             DO ACTION)
    [COND
      ((NULL LIST:OF:POSSIBLE:CLASS:NAMES)
        (PRINT (QUOTE (I DONT KNOW WHAT IT IS, WHAT IS IT?)))
        (RETURN (QUOTE FAILURE]
    (PROG (RESULT:1)
      LABEL:1
          (SET POSSIBLE:CLASS:NAME (CAR LIST:OF:POSSIBLE:CLASS:NAMES))
          (SETQ LIST:OF:POSSIBLE:CLASS:NAMES (CDR 
                                       LIST:OF:POSSIBLE:CLASS:NAMES))
          (SETQ RESULT:1 (EVAL ACTION))
          (COND
            ((NOT (NULL RESULT:1))
              (PRINT (QUOTE (I BELIEVE THIS IS A)))
              (PRINT POSSIBLE:CLASS:NAME)
              (PRINT (QUOTE (WHAT IS IT?)))
              (SETQ CLASS:NAME POSSIBLE:CLASS:NAME)
              (RETURN (EVAL POSSIBLE:CLASS:NAME)))
            (LIST:OF:POSSIBLE:CLASS:NAMES (GO LABEL:1))
            (T (RETURN (PRINT (QUOTE (I DONT KNOW WHAT IT IS, WHAT IS 
                                        IT?)))
                       (RETURN (QUOTE FAILURE])

(FOREACH:1:2:1
  [LAMBDA (YES:RELATION IN SET:OF:YES:RELATIONS DO UNTIL 
                                                    UNTIL:CONDITION 
                                                         ACTION)
    (COND
      ((NULL SET:OF:YES:RELATIONS)
        T))
    (PROG (RESULT:1:2:1)
      LABEL:1:2:1
          (SET YES:RELATION (CAR SET:OF:YES:RELATIONS))
          (SETQ SET:OF:YES:RELATIONS (CDR SET:OF:YES:RELATIONS))
          (SETQ RESULT:1:2:1 (EVAL ACTION))
          (COND
            ((EVAL UNTIL:CONDITION)
              (RETURN NIL))
            (SET:OF:YES:RELATIONS (GO LABEL:1:2:1))
            (T (RETURN RESULT:1:2:1])

(FOREACH:1:2:2
  [LAMBDA (NO:RELATION IN SET:OF:NO:RELATIONS DO UNTIL UNTIL:CONDITION 
                                                       ACTION)
    (COND
      ((NULL SET:OF:NO:RELATIONS)
        T))
    (PROG (RESULT:1:2:2)
      LABEL:1:2:2
          (SET NO:RELATION (CAR SET:OF:NO:RELATIONS))
          (SETQ SET:OF:NO:RELATIONS (CDR SET:OF:NO:RELATIONS))
          (SETQ RESULT:1:2:2 (EVAL ACTION))
          (COND
            ((EVAL UNTIL:CONDITION)
              (RETURN NIL))
            (SET:OF:NO:RELATIONS (GO LABEL:1:2:2))
            (T (RETURN RESULT:1:2:2])

(FOREACH:1:2:3
  [LAMBDA (MAYBE:RELATION IN SET:OF:MAYBE:RELATIONS DO UNTIL 
                                                    UNTIL:CONDITION 
                                                             ACTION)
    (COND
      ((NULL SET:OF:MAYBE:RELATIONS)
        T))
    (PROG (RESULT:1:2:3)
      LABEL:1:2:3
          (SET MAYBE:RELATION (CAR SET:OF:MAYBE:RELATIONS))
          (SETQ SET:OF:MAYBE:RELATIONS (CDR SET:OF:MAYBE:RELATIONS))
          (SETQ RESULT:1:2:3 (EVAL ACTION))
          (COND
            ((EVAL UNTIL:CONDITION)
              (RETURN NIL))
            (SET:OF:MAYBE:RELATIONS (GO LABEL:1:2:3))
            (T (RETURN RESULT:1:2:3])

(FORSOME:1
  [LAMBDA (RELATION IN SET:DIFF DO ACTION)
    (COND
      ((NULL SET:DIFF)
        NIL))
    (SET RELATION (CAR SET:DIFF))
    (EVAL ACTION)
    T])

(FORSOME:2
  [LAMBDA (RELATION IN SET:DIFF DO ACTION)
    (COND
      ((NULL SET:DIFF)
        NIL))
    (SET RELATION (CAR SET:DIFF))
    (EVAL ACTION)
    T])

(HALT:1
  [LAMBDA NIL
    (OUTPUT:1 LIST:OF:POSSIBLE:CLASS:NAMES)
    (COND
      ((EQUAL (ASK:FOR:2 (QUOTE SHOULD:I:CONTINUE:ON)
                         (QUOTE YES))
              (PARTITION:A:DOMAIN))
        (T NIL])

(HAS:NAME
  [LAMBDA (ELEMENT)
    (NOT (EQUAL (CAR ELEMENT)
                (QUOTE ?])

(INITIALIZE:1
  [LAMBDA NIL
    (SAVESETQ YES:RELATIONS (QUOTE YES:RELATIONS))
    (SAVESETQ NO:RELATIONS (QUOTE NO:RELATIONS))
    (SAVESETQ MAYBE:RELATIONS (QUOTE MAYBE:RELATIONS))
    (SAVESETQ CLASS:OBJECTS (QUOTE CLASS:OBJECTS))
    (SETQ CLASS:NAMES:ORDERING (QUOTE CLASS:NAMES:ORDERING))
    (SAVESETQ IN (QUOTE IN))
    (SAVESETQ UNTIL (QUOTE UNTIL))
    (SAVESETQ DO (QUOTE DO))
    (SAVESETQ FROM (QUOTE FROM))
    (SAVESETQ TO (QUOTE TO))
    (SETQ USING (QUOTE USING))
    (SAVESETQ LIST:OF:POSSIBLE:CLASS:NAMES NIL)
    (SAVESETQ FILE:NAME (ASK:FOR:2 (QUOTE FILE:NAME])

(INPUT:1:ELEMENT
  [LAMBDA NIL
    (PRINT (QUOTE (I AM READY FOR A SCENE)))
    (SETQ ELEMENT (READ))
    (SETQ LIST:OF:OBJECTS:OF:ELEMENT (CORRESPONDING:OBJECTS:PART 
                                                            ELEMENT))
    (SETQ SET:OF:RELATIONS (CORRESPONDING:RELATIONS:PART ELEMENT))
    (SETQ CLASS:NAME (CAR ELEMENT])

(INPUT:2:CLASS:NAME
  [LAMBDA NIL
    (SETQ CLASS:NAME CLASS:NAME)
    (COND
      ([AND (NOT (MEMBER CLASS:NAME LIST:OF:POSSIBLE:CLASS:NAMES))
            (AND (NOT (EQUAL CLASS:NAME (QUOTE NIL)))
                 (NOT (EQUAL CLASS:NAME (QUOTE NOTHING]
        (INSERT:2:LIST:OF:CLASS:NAMES CLASS:NAME))
      (COND
        ((MEMBER CLASS:NAME LIST:OF:POSSIBLE:CLASS:NAMES)
          (RECONCILE:1 ELEMENT CLASS:NAME])

(INSERT:1
  [LAMBDA (CORRECT:CLASS:NAME)
    (SETQ LIST:OF:POSSIBLE:CLASS:NAMES (MERGE:1 CORRECT:CLASS:NAME 
                                       LIST:OF:POSSIBLE:CLASS:NAMES 
                                               CLASS:NAMES:ORDERING))
    (PUT CORRECT:CLASS:NAME YES:RELATIONS NIL)
    (PUT CORRECT:CLASS:NAME NO:RELATIONS NIL)
    (PUT CORRECT:CLASS:NAME MAYBE:RELATIONS SET:OF:RELATIONS)
    (PUT CORRECT:CLASS:NAME CLASS:OBJECTS LIST:OF:OBJECTS:OF:ELEMENT])

(INSERT:1:1
  [LAMBDA (RELATION P:LIST)
    (PROG (TEMPORARY:YES:RELATIONS)
          (SETQ TEMPORARY:YES:RELATION (GETP CLASS:NAME YES:RELATIONS))
          (SETQ TEMPORARY:YES:RELATIONS (CONS RELATION 
                                            TEMPORARY:YES:RELATIONS))
          (PUT CLASS:NAME YES:RELATIONS TEMPORARY:YES:RELATIONS])

(INSERT:2
  [LAMBDA (CLASS:NAME)
    (SETQ LIST:OF:POSSIBLE:CLASS:NAMES (MERGE:1 CLASS:NAME 
                                       LIST:OF:POSSIBLE:CLASS:NAMES 
                                               CLASS:NAMES:ORDERING))
    (PUT CLASS:NAME YES:RELATIONS NIL)
    (PUT CLASS:NAME NO:RELATIONS NIL)
    (PUT CLASS:NAME MAYBE:RELATIONS SET:OF:RELATIONS)
    (PUT CLASS:NAME CLASS:OBJECTS LIST:OF:OBJECTS:OF:ELEMENT])

(INSERT:2:1
  [LAMBDA (RELATION P:LIST)
    (PROG (TEMPORARY:NO:RELATIONS)
          (SETQ TEMPORARY:NO:RELATION (GETP CLASS:NAME NO:RELATIONS))
          (SETQ TEMPORARY:NO:RELATIONS (CONS RELATION 
                                             TEMPORARY:NO:RELATIONS))
          (PUT CLASS:NAME NO:RELATIONS TEMPORARY:NO:RELATIONS])

(MERGE:1
  [LAMBDA (E L F)
    (COND
      ((OR (NULL L)
           (APPLY* F E (CAR L)))
        (CONS E L))
      (T (CONS (CAR L)
               (MERGE:1 E (CDR L)
                        F])

(OUTPUT:1
  [LAMBDA (LIST:OF:POSSIBLE:CLASS:NAMES)
    (FOREACH (QUOTE POSSIBLE:CLASS:NAME) IN 
                                       LIST:OF:POSSIBLE:CLASS:NAMES
       DO (QUOTE (DISK:DUMP FILE:NAME (LIST POSSIBLE:CLASS:NAME
                                            (GETP POSSIBLE:CLASS:NAME 
                                                  CLASS:OBJECTS)
                                            (GETP POSSIBLE:CLASS:NAME 
                                                  YES:RELATIONS)
                                            (GETP POSSIBLE:CLASS:NAME 
                                                  NO:RELATIONS)
                                            (GETP POSSIBLE:CLASS:NAME 
                                                  MAYBE:RELATIONS])

(PARTITION:A:DOMAIN
  [LAMBDA NIL
    (PROG NIL
      START:OF:SERIES
          (INPUT:1:ELEMENT)
          (COND
            ((HAS:NAME ELEMENT)
              (INPUT:2:CLASS:NAME))
            (T (DETERMINE:1:CLASS:NAME)))
          (COND
            ((EQUAL CLASS:NAME (QUOTE HALT))
              (HALT))
            (T (PRINT (QUOTE (I NOW KNOW)))
               [FOREACH (QUOTE NAME) IN LIST:OF:POSSIBLE:CLASS:NAMES
                  DO (QUOTE (PROGN (PRINT NAME)
                                   [COND
                                     ((GETP NAME CLASS:OBJECTS)
                                       (PRIN1 (QUOTE "OBJECTS "))
                                       (PRINT (GETP NAME CLASS:OBJECTS]
                                   [COND
                                     ((GETP NAME YES:RELATIONS)
                                       (PRIN1 (QUOTE "MUST HAVW "))
                                       (PRINT (GETP NAME YES:RELATIONS]
                                   [COND
                                     ((GETP NAME NO:RELATIONS)
                                       (PRIN1 (QUOTE "MUSNT HAVE "))
                                       (PRINT (GETP NAME NO:RELATIONS]
                                   (COND
                                     ((GETP NAME MAYBE:RELATIONS)
                                       (PRIN1 (QUOTE "MAY HAVE "))
                                       (PRINT (GETP NAME 
                                                    MAYBE:RELATIONS]
               (GO START:OF:SERIES])

(PULLOUT
  [LAMBDA (E L)
    (COND
      ((ATOM L)
        L)
      ((EQUAL E (CAR L))
        (CDR L))
      (T (CONS (CAR L)
               (PULLOUT E (CDR L])

(RECONCILE:1
  [LAMBDA (CLASS:NAME ELEMENT)
    (SETQ LIST:OF:OBJECTS:OF:CLASS (GETP CLASS:NAME CLASS:OBJECTS))
    (SETQ SET:OF:YES:RELATIONS (GETP CLASS:NAME YES:RELATIONS))
    (SETQ SET:OF:NO:RELATIONS (GETP CLASS:NAME NO:RELATIONS))
    (SETQ SET:OF:MAYBE:RELATIONS (GETP CLASS:NAME MAYBE:RELATIONS))
    (RECONCILE:1:1 LIST:OF:OBJECTS:OF:CLASS LIST:OF:OBJECTS:OF:ELEMENT 
                   CLASS:NAME)
    (RECONCILE:1:2 SET:OF:YES:RELATIONS SET:OF:RELATIONS CLASS:NAME)
    (RECONCILE:1:3 SET:OF:NO:RELATIONS SET:OF:RELATIONS CLASS:NAME)
    (RECONCILE:1:4 SET:OF:MAYBE:RELATIONS SET:OF:RELATIONS CLASS:NAME])

(RECONCILE:1:1
  [LAMBDA (LIST:OF:OBJECTS:OF:CLASS LIST:OF:OBJECTS:OF:ELEMENT 
                                    CLASS:NAME)
    (SETQ NEW:LIST:OF:OBJECTS:OF:CLASS (RENAME:1:1 
                                           LIST:OF:OBJECTS:OF:CLASS 
                                         LIST:OF:OBJECTS:OF:ELEMENT))
    (SETQ NEW:LIST:OF:OBJECTS:OF:ELEMENT (RENAME:1:2 
                                           LIST:OF:OBJECTS:OF:CLASS 
                                         LIST:OF:OBJECTS:OF:ELEMENT))
    (REWRITE:1 SET:OF:RELATIONS USING LIST:OF:OBJECTS:OF:ELEMENT 
               NEW:LIST:OF:OBJECTS:OF:ELEMENT CLASS:NAME)
    (REWRITE:2 SET:OF:YES:RELATIONS USING LIST:OF:OBJECTS:OF:CLASS 
               NEW:LIST:OF:OBJECTS:OF:CLASS CLASS:NAME)
    (REWRITE:3 SET:OF:NO:RELATIONS USING LIST:OF:OBJECTS:OF:CLASS 
               NEW:LIST:OF:OBJECTS:OF:CLASS CLASS:NAME)
    (REWRITE:4 SET:OF:MAYBE:RELATIONS USING LIST:OF:OBJECTS:OF:CLASS 
               NEW:LIST:OF:OBJECTS:OF:CLASS CLASS:NAME)
    (REWRITE:5 LIST:OF:OBJECTS:OF:ELEMENT USING 
               NEW:LIST:OF:OBJECTS:OF:ELEMENT CLASS:NAME)
    (REWRITE:6 LIST:OF:OBJECTS:OF:CLASS USING 
               NEW:LIST:OF:OBJECTS:OF:CLASS CLASS:NAME])

(RECONCILE:1:2
  [LAMBDA (SET:OF:YES:RELATIONS SET:OF:RELATIONS CLASS:NAME)
    (FOREACH (QUOTE RELATION) IN (SETDIFFERENCE SET:OF:YES:RELATIONS 
                                                SET:OF:RELATIONS)
       DO (TRANSFER RELATION FROM SET:OF:YES:RELATIONS TO 
                                             SET:OF:MAYBE:RELATIONS])

(RECONCILE:1:3
  [LAMBDA (SET:OF:NO:RELATIONS SET:OF:RELATIONS CLASS:NAME)
    (FOREACH RELATION IN (SETINTERSECTION SET:OF:RELATIONS 
                                          SET:OF:NO:RELATIONS)
       DO (QUOTE (TRANSFER RELATION FROM SET:OF:NO:RELATIONS
                    TO SET:OF:MAYBE:RELATIONS])

(RECONCILE:1:4
  [LAMBDA (SET:OF:MAYBE:RELATIONS SET:OF:RELATIONS CLASS:NAME)
    (FOREACH (QUOTE RELATION) IN (SETDIFFERENCE SET:OF:RELATIONS
                                                (SETUNION 
                                               SET:OF:YES:RELATIONS 
                                                SET:OF:NO:RELATIONS 
                                             SET:OF:MAYBE:RELATIONS))
       DO (QUOTE (TRANSFER RELATION FROM SET:OF:RELATIONS TO 
                                             SET:OF:MAYBE:RELATIONS])

(RENAME:1:1
  [LAMBDA (L1 L2)
    (APPEND (COND
              [L1 [COND
                    (L2 (LIST (CAR L2)))
                    (T (LIST (CAR L1]
                  (T (COND
                       (L2 (LIST (CAR L2)))
                       (T NIL]
              (COND
                ((OR L1 L2)
                  (RENAME:1:1 (CDR L1)
                              (CDR L2)))
                (T NIL])

(RENAME:1:2
  [LAMBDA (L1 L2)
    (APPEND (COND
              ((AND L1 L2)
                (LIST (CAR L2)))
              (T L1))
            (COND
              ((AND L1 L2)
                (RENAME:1:2 (CDR L1)
                            (CDR L2)))
              (T NIL])

(REWRITE:1
  [LAMBDA (SET:OF:RELATIONS USING LIST:OF:OBJECTS:OF:ELEMENT 
                            NEW:LIST:OF:OBJECTS:OF:ELEMENT CLASS:NAME)
    (PROG (NEW:1 OLD:1)
      LABEL:1
          (COND
            ((NULL LIST:OF:OBJECTS:OF:ELEMENT)
              (RETURN SET:OF:RELATIONS))
            ((NULL NEW:LIST:OF:OBJECTS:OF:ELEMENT)
              (RETURN SET:OF:RELATIONS)))
          (SETQ NEW:1 (CAR NEW:LIST:OF:OBJECTS:OF:ELEMENT))
          (SETQ OLD:1 (CAR LIST:OF:OBJECTS:OF:ELEMENT))
          (SUBSTITUTE NEW:1 FOR OLD:1 IN SET:OF:RELATIONS)
          (GO LABEL:1])

(REWRITE:2
  [LAMBDA (SET:OF:YES:RELATIONS USING LIST:OF:OBJECTS:OF:CLASS 
                                NEW:LIST:OF:OBJECTS:OF:CLASS CLASS:NAME)
    (PROG (OLD:2 NEW:2)
      LABEL:2
          (COND
            ((NULL LIST:OF:OBJECTS:OF:CLASS)
              (PUT CLASS:NAME YES:RELATIONS SET:OF:YES:RELATIONS)
              (RETURN SET:OF:YES:RELATIONS))
            ((NULL NEW:LIST:OF:OBJECTS:OF:CLASS)
              (PUT CLASS:NAME YES:RELATIONS SET:OF:YES:RELATIONS)
              (RETURN SET:OF:YES:RELATIONS)))
          (SETQ OLD:2 (CAR LIST:OF:OBJECTS:OF:CLASS))
          (SETQ NEW:2 (CAR NEW:LIST:OF:OBJECTS:OF:CLASS))
          (SUBSTITUTE NEW:2 FOR OLD:2 IN SET:OF:YES:RELATIONS)
          (GO LABEL:2])

(REWRITE:3
  [LAMBDA (SET:OF:NO:RELATIONS USING LIST:OF:OBJECTS:OF:CLASS 
                               NEW:LIST:OF:OBJECTS:OF:CLASS CLASS:NAME)
    (PROG (OLD:3 NEW:3)
      LABEL:3
          (COND
            ((NULL LIST:OF:OBJECTS:OF:CLASS)
              (PUT CLASS:NAME NO:RELATIONS SET:OF:NO:RELATIONS)
              (RETURN SET:OF:NO:RELATIONS))
            ((NULL NEW:LIST:OF:OBJECTS:OF:CLASS)
              (PUT CLASS:NAME NO:RELATIONS SET:OF:NO:RELATIONS)
              (RETURN SET:OF:NO:RELATIONS)))
          (SETQ OLD:3 (CAR LIST:OF:OBJECTS:OF:CLASS))
          (SETQ NEW:3 (CAR NEW:LIST:OF:OBJECTS:OF:CLASS))
          (SUBSTITUTE NEW:3 FOR OLD:3 IN SET:OF:NO:RELATIONS)
          (GO LABEL:3])

(REWRITE:4
  [LAMBDA (SET:OF:MAYBE:RELATIONS USING LIST:OF:OBJECTS:OF:CLASS 
                                  NEW:LIST:OF:OBJECTS:OF:CLASS 
                                  CLASS:NAME)
    (PROG (OLD:4 NEW:4)
      LABEL:4
          (COND
            ((NULL LIST:OF:OBJECTS:OF:CLASS)
              (PUT CLASS:NAME MAYBE:RELATIONS SET:OF:MAYBE:RELATIONS)
              (RETURN SET:OF:MAYBE:RELATIONS))
            ((NULL NEW:LIST:OF:OBJECTS:OF:CLASS)
              (PUT CLASS:NAME MAYBE:RELATIONS SET:OF:MAYBE:RELATIONS)
              (RETURN SET:OF:MAYBE:RELATIONS)))
          (SETQ OLD:4 (CAR LIST:OF:OBJECTS:OF:CLASS))
          (SETQ NEW:4 (CAR NEW:LIST:OF:OBJECTS:OF:CLASS))
          (SUBSTITUTE NEW:4 FOR OLD:4 IN SET:OF:MAYBE:RELATIONS)
          (GO LABEL:4])

(REWRITE:5
  [LAMBDA (LIST:OF:OBJECTS:OF:ELEMENT USING 
                                     NEW:LIST:OF:OBJECTS:OF:ELEMENT 
                                      CLASS:NAME)
    (SETQ LIST:OF:OBJECTS:OF:ELEMENT NEW:LIST:OF:OBJECTS:OF:ELEMENT])

(REWRITE:6
  [LAMBDA (LIST:OF:OBJECTS:OF:CLASS USING NEW:LIST:OF:OBJECTS:OF:CLASS 
                                    CLASS:NAME)
    (SETQ LIST:OF:OBJECTS:OF:CLASS NEW:LIST:OF:OBJECTS:OF:CLASS)
    (PUT CLASS:NAME CLASS:OBJECTS LIST:OF:OBJECTS:OF:CLASS])

(SETDIFFERENCE
  [LAMBDA (S1 S2)
    (COND
      ((NULL S1)
        NIL)
      (T (APPEND [COND
                   ((MEMBER (CAR S1)
                            S2)
                     NIL)
                   (T (LIST (CAR S1]
                 (SETDIFFERENCE (CDR S1)
                                S2])

(SETINTERSECTION
  [LAMBDA (S1 S2)
    (INTERSECTION S1 S2])

(SETUNION
  [LAMBDA (S1 S2)
    (SETQ S1 (APPEND S1 S2))
    (INTERSECTION S1 S1])

(SUBSTITUTE
  [LAMBDA (NEW FOR OLD IN SET)
    (SUBST NEW OLD SET])

(TEST:1
  [LAMBDA (POSSIBLE:CLASS:NAME)
    (COMPARE:1 POSSIBLE:CLASS:NAME ELEMENT])

(TRANSFER:1
  [LAMBDA (RELATION FROM SET:OF:MAYBE:RELATIONS TO SET:OF:YES:RELATIONS)
    (SETQ NEW:SET:OF:YES:RELATIONS (CONS RELATION SET:OF:YES:RELATIONS))
    (INSERT:1:1 RELATION (QUOTE (PROPERTY YES:RELATIONS
                                   ON PROPERTY:LIST OF CLASS:NAME)))
    (SETQ NEW:SET:OF:MAYBE:RELATIONS (PULLOUT RELATION 
                                             SET:OF:MAYBE:RELATIONS))
    (DELETE:1:1 RELATION (QUOTE (PROPERTY (MAYBE:RELATIONS
                                             ON PROPERTY:LIST OF 
                                                CLASS:NAME])

(TRANSFER:2
  [LAMBDA (RELATION FROM SET:OF:RELATIONS TO SET:OF:NO:RELATIONS)
    (SETQ NEW:SET:OF:NO:RELATIONS (CONS RELATION SET:OF:NO:RELATIONS))
    (INSERT:2:1 RELATION (QUOTE (PROPERTY NO:RELATIONS
                                   ON PROPERTY:LIST OF CLASS:NAME)))
    (SETQ NEW:SET:OF:RELATIONS (PULLOUT RELATION SET:OF:RELATIONS])
)
  (LISPXPRINT (QUOTE PUP2FNS)
              T)
  (RPAQQ PUP2FNS
         (AD ASK:FOR:1 ASK:FOR:2 CF COMPARE:1 COMPARE:1:1 COMPARE:1:2 
             COMPARE:1:2:1 COMPARE:1:2:1:1 COMPARE:1:2:2 
             COMPARE:1:2:2:1 COMPARE:1:2:3 COMPARE:1:2:3:1 
             CONTRADICTS:1 CONTRADICTS:2 CONTRADICTS:3 
             CORRESPONDING:OBJECTS:PART CORRESPONDING:RELATIONS:PART 
             DELETE:1:1 DETERMINE:1:CLASS:NAME DISK:DUMP FOREACH 
             FOREACH:1 FOREACH:1:2:1 FOREACH:1:2:2 FOREACH:1:2:3 
             FORSOME:1 FORSOME:2 HALT:1 HAS:NAME INITIALIZE:1 
             INPUT:1:ELEMENT INPUT:2:CLASS:NAME INSERT:1 INSERT:1:1 
             INSERT:2 INSERT:2:1 MERGE:1 OUTPUT:1 PARTITION:A:DOMAIN 
             PULLOUT RECONCILE:1 RECONCILE:1:1 RECONCILE:1:2 
             RECONCILE:1:3 RECONCILE:1:4 RENAME:1:1 RENAME:1:2 
             REWRITE:1 REWRITE:2 REWRITE:3 REWRITE:4 REWRITE:5 
             REWRITE:6 SETDIFFERENCE SETINTERSECTION SETUNION 
             SUBSTITUTE TEST:1 TRANSFER:1 TRANSFER:2))
STOP